API: Add gtk_widget_draw()

And here's the final patch that all the previous patches were about.

API: gtk_cell_renderer_render_cairo() => gtk_cell_renderer_render()

API: Remove gtk_cell_renderer_render()

The next commit will rename gtk_cell_renderer_render_cairo() to
gtk_cell_renderer_render() again

API: Get rid of gtk_draw_insertion_cursor()

and rename gtk_cairo_draw_insertion_cursor() to
gtk_draw_insertion_cursor().

API: Rename gtk_cairo_paint_*() to gtk_paint_*()

Large patch, but just renaming.
Indentation should still mostly be correct because I took care of
keeping the indentation for this function name.

API: style: Remove old drawing functions

API: widget: Remove the expose event

gtk_widget_send_expose() now calls the draw function.

API: Remove gtk_container_propagate_expose()

Also, move the documentation to its replacement
gtk_widget_propagate_draw().

container: Implement gtk_container_propagate_draw() without fallbacks

No more fallbacks to gtk_container_propagate_expose().

Change semantics of the draw signal

Previously, we tried to move the context's origin to the widget's top
left location, no matter what window the paint was happening on. Now we
only do that for child windows of the widget's window and leave the
context untouched for windows that the widget has created outside its
own hierarchy. In those casses, we also don't clip the context to
the widget's allocation.

Includes fixes to GtkHandlebox for this effect and fixes all known
issues with it.

These semantics assume that gtk_widget_draw() should only draw the parts
of a widget that are inside child windows and not draw stuff that is
located in completely different GdkWindows. In the handlebox case, it
means that it should only draw the handle when it is attached, but not
when it isn't. We'll likely need a special draw function for the
detached handlebox if we want to draw it.

widget: Clip drawing to the widget's allocation.

I've seen (and written) quite some widgets (and theme engines) that use
cairo_paint() to draw the background. So avoiding overdraw makes sense.

Also move all that setup into a _gtk_widget_draw_internal() function
that will be used by all functions that can be used by other functions
that draw widgets.

iconfactory: Initialize varibale to NULL in failure path

Otherwise we use random memory and that is not good.

image: Add a default case to switch statement to avoid gcc warnings

test: Port offscreen test to draw vfunc

gtk-demo: Port offscreen example to draw vfunc

gtk-demo: Port offscreen example to draw vfunc

testgtk: Use draw signal in layout test

testgtk: Use draw signal in scrolling test

testgtk: Use draw signal in cursors example

testgtk: Remove non-existing property from frame constructor

testgtk: Use draw signal in gridded geometry example

testgtk: Make big windows test not use expose events

Instead, use gdk_window_set_background().

testgtk: Use draw signal in resize grips example

x11: When querying window size, ask the wrapper, not ourselves

gdk: Make GdkWindow cope better with its surface outliving the window

Make extra sure we release the surface properly. Also make sure that the
released surface doesn't keep any references to us.

tests: Use draw vfunc in print-editor

testoffscreen: Connect to draw signal

tests: Use draw signal in testinput

testpixbuf-save: Use the draw signal

testpixbuf-scale: Connect to draw signal

pixbuf-demo: Use draw signal

gtk-demo: Use draw signal in color selection demo

testtooltips: Connect to draw signal

testtooltips: Don't call gdk_window_get_pointer() in expose events

testgtk: Connect to draw signal in "rotated text" example

testgtk: Connect to draw signals in "composited window" example

testgtk: Connect to draw signal in alpha test

Test still behaves weird, no idea why though.

tests: Connect to draw signal in testimage

tests: Connect to draw signal in testoffscreenwindow

tests: Connect to draw signal in testellipsise

The test seems broken, not sure why.

testcairo: Connect to draw signal

perf: Connect to draw signal

imcontextxim: Connect to draw signal

gtk-demo: Connect to draw signal in rotated-text

gtk-demo: Connect to draw signal in pixbufs example

gtk-demo: Connet to draw signal in drawingarea example

printunixdialog: Connect to draw vfunc

printunixdialog: Connect to draw signal for collate callback

dnd-quartz: Connect to draw func for dnd hilight

dnd: Connect to raw func for drag hilight

colorsel: Connect to draw signal

filechooserentry: Connect to draw event

colorbutton: Connect to draw event

notebook: Connect to draw signal

tooltip: Connect to draw signal

toolitemgroup: Connect to draw signal

assistant: Port to draw vfunc

trayicon: Port to draw vfunc

window: Port to draw vfunc

window: Remove hack to set background

I can't see this having any effect in current code, but who knows...

expander: Port to draw vfunc

frame: Port to draw vfunc

frame: Remove unneeded is_drawable() check

API: checkbutton: Port to draw vfunc

Requires changing the API of the draw_indicator vfunc.

radiobutton: Remove redundant is_drawable() check

checkbutton: Remove redundant is_drawable() check

checkbutton: Remove excessive is_drawable() check

handlebox: Port to draw vfunc

handlebox: Simplify painting code

handlebox: Don't draw outside of expose events

We do a queue_draw() via queue_resize() here, so everything's fine.

button: Port to draw vfunc

Also port togglebutton, they use the same paint function.

button: Remove is_drawable() check

It's already done in the expose function

tearoffmenuitem: remove is_drawable() check

API: checkmenuitem: Port to draw vfunc

Requires changing the draw_indicator vfunc to take a cairo_t.

tearoffmenuitem: Port to draw vfunc

tearoffmenuitem: Don't clear the window, it should be clear already

tearoffmenuitem: Merge paint() into expose()

menuitem: Remove is_drawable() check

menuitem: Port to draw vfunc

menuitem: Move paint function into expose function

combobox: Port to draw vfunc

eventbox: Port to draw vfunc

eventbox: Merge paint function into expose function

scrolledwindow: Port to draw vfunc

scrolledwindow: Move paint function into expose handler

Also remove the is_drawable() check. It will not be needed once we have
the draw vfunc.

viewport: No need to check if the widget is drawable anymore

viewport: Port to draw vfunc

viewport: Pass sizes explicitly to paint functions

viewport: Merge gtk_viewport_paint() into expose function

viewport: Don't paint stuff in realize handler

notebook: Port to draw vfunc

notebook: The drawable check is not necessary

Large patch, but that's only indentation.

notebook: Draw tabs and arrows with Cairo

Includes a fix to only draw the current page once during a drag
operation.

notebook: Simplify draw_tab function a bit

Don't keep lots of local variables that are only used once.

notebook: remove check for is_drawable

When we reach that code, the widget will always be drawable

notebook: Reorder expose function in preparation of draw vfunc

notebook: Use a for loop when iterating over a list

notebook: Draw focus when drawing tab

Instead of using a special function, draw the focus of a tab when the
tab actually is painted. Simplifies the code quite a bit.

notebook: Remove useless optimization

It will become especially useless once we draw with Cairo exclusively.

paned: Port to draw vfunc